namespace ext.util
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <summary>
	/// Base class that provides a common interface for publishing events. Subclasses are expected to
	/// to have a property &quot;events&quot; with all the events defined, and, optionally, a property &quot;listeners&quot;
	/// with configured listeners defined.
	/// </summary>
	/// <htmlSummary>
	/// Base class that provides a common interface for publishing events. Subclasses are expected to
	/// to have a property &quot;events&quot; with all the events defined, and, optionally, a property &quot;listeners&quot;
	/// with configured listeners defined.&lt;br&gt;
	/// For example:
	/// &lt;pre&gt;&lt;code&gt;
	/// Employee = Ext.extend(Ext.util.Observable, {
	/// constructor: function(config){
	/// this.name = config.name;
	/// this.addEvents({
	/// &quot;fired&quot; : true,
	/// &quot;quit&quot; : true
	/// });
	///
	/// // Copy configured listeners into *this* object so that the base class&amp;#39;s
	/// // constructor will add them.
	/// this.listeners = config.listeners;
	///
	/// // Call our superclass constructor to complete construction process.
	/// Employee.superclass.constructor.call(this, config)
	/// }
	/// });
	/// &lt;/code&gt;&lt;/pre&gt;
	/// This could then be used like this:&lt;pre&gt;&lt;code&gt;
	/// var newEmployee = new Employee({
	/// name: employeeName,
	/// listeners: {
	/// quit: function() {
	/// // By default, &quot;this&quot; will be the object that fired the event.
	/// alert(this.name + &quot; has quit!&quot;);
	/// }
	/// }
	/// });
	/// &lt;/code&gt;&lt;/pre&gt;
	/// </htmlSummary>
	/// <definedin>src\ext-core\src\util\Observable.js</definedin>
	/// <definedin>src\util\Observable-more.js</definedin>
	/// <definedin>src\util\Observable-more.js</definedin>
	[ScriptName("Observable")]
	[ScriptNamespace("Ext.util")]
	[Imported()]
	public partial class Observable
	{
		
		#region Constructors
		public Observable(ext.util.Observable_Configuration config)
		{
		}
		
		/// <summary>Constructor</summary>
		public Observable()
		{
		}
		#endregion
		
		#region Fields
		/// <summary>
		/// A config object containing one or more event handlers to be added to this
		/// object during initialization. This should be a valid listeners config object as specified in the
		/// {@link #addListener} example for attaching multiple handlers at once.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;A config object containing one or more event handlers to be added to this
		/// object during initialization. This should be a valid listeners config object as specified in the
		/// {@link #addListener} example for attaching multiple handlers at once.&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;&lt;u&gt;DOM events from ExtJs {@link Ext.Component Components}&lt;/u&gt;&lt;/b&gt;&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;While &lt;i&gt;some&lt;/i&gt; ExtJs Component classes export selected DOM events (e.g. &quot;click&quot;, &quot;mouseover&quot; etc), this
		/// is usually only done when extra value can be added. For example the {@link Ext.DataView DataView}&apos;s
		/// &lt;b&gt;&lt;code&gt;{@link Ext.DataView#click click}&lt;/code&gt;&lt;/b&gt; event passing the node clicked on. To access DOM
		/// events directly from a Component&apos;s HTMLElement, listeners must be added to the &lt;i&gt;{@link Ext.Component#getEl Element}&lt;/i&gt; after the Component
		/// has been rendered. A plugin can simplify this step:&lt;pre&gt;&lt;code&gt;
		/// // Plugin is configured with a listeners config object.
		/// // The Component is appended to the argument list of all handler functions.
		/// Ext.DomObserver = Ext.extend(Object, {
		/// constructor: function(config) {
		/// this.listeners = config.listeners ? config.listeners : config;
		/// },
		///
		/// // Component passes itself into plugin&amp;#39;s init method
		/// init: function(c) {
		/// var p, l = this.listeners;
		/// for (p in l) {
		/// if (Ext.isFunction(l[p])) {
		/// l[p] = this.createHandler(l[p], c);
		/// } else {
		/// l[p].fn = this.createHandler(l[p].fn, c);
		/// }
		/// }
		///
		/// // Add the listeners to the Element immediately following the render call
		/// c.render = c.render.{@link Function#createSequence createSequence}(function() {
		/// var e = c.getEl();
		/// if (e) {
		/// e.on(l);
		/// }
		/// });
		/// },
		///
		/// createHandler: function(fn, c) {
		/// return function(e) {
		/// fn.call(this, e, c);
		/// };
		/// }
		/// });
		///
		/// var combo = new Ext.form.ComboBox({
		///
		/// // Collapse combo when its element is clicked on
		/// plugins: [ new Ext.DomObserver({
		/// click: function(evt, comp) {
		/// comp.collapse();
		/// }
		/// })],
		/// store: myStore,
		/// typeAhead: true,
		/// mode: &apos;local&apos;,
		/// triggerAction: &apos;all&apos;
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <optional>Optional Field</optional>
		[ScriptName("listeners")]
		public object Listeners;
		#endregion
		
		#region Methods
		/// <summary>Removes all listeners for this object</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		[ScriptName("purgeListeners")]
		public void PurgeListeners()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Checks to see if this object has any listeners for a specified event</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The name of the event to check for</param>
		/// <returns>True if the event is being listened for, else false</returns>
		[ScriptName("hasListener")]
		public bool HasListener(string eventName)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Suspend the firing of all events. (see {@link #resumeEvents})</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="queueSuspended">
		/// Pass as true to queue up suspended events to be fired
		/// after the {@link #resumeEvents} call instead of discarding all suspended events;
		/// </param>
		[ScriptName("suspendEvents")]
		public void SuspendEvents(bool queueSuspended)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Resume firing events. (see {@link #suspendEvents})
		/// If events were suspended using the queueSuspended parameter, then all
		/// events fired during event suspension will be sent to any listeners now.
		/// </summary>
		/// <htmlSummary>
		/// Resume firing events. (see {@link #suspendEvents})
		/// If events were suspended using the &lt;tt&gt;&lt;b&gt;queueSuspended&lt;/b&gt;&lt;/tt&gt; parameter, then all
		/// events fired during event suspension will be sent to any listeners now.
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		[ScriptName("resumeEvents")]
		public void ResumeEvents()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes all added captures from the Observable.</summary>
		/// <htmlSummary>Removes &lt;b&gt;all&lt;/b&gt; added captures from the Observable.</htmlSummary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="o">The Observable to release</param>
		[ScriptName("releaseCapture")]
		public static void ReleaseCapture(ext.util.Observable o)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Relays selected events from the specified Observable as if the events were fired by this.</summary>
		/// <htmlSummary>Relays selected events from the specified Observable as if the events were fired by &lt;tt&gt;&lt;b&gt;this&lt;/b&gt;&lt;/tt&gt;.</htmlSummary>
		/// <definedin>src\util\Observable-more.js</definedin>
		/// <param name="o">The Observable whose events this object is to relay.</param>
		/// <param name="events">Array of event names to relay.</param>
		[ScriptName("relayEvents")]
		public void RelayEvents(object o, System.Array events)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets observability on the passed class constructor.  This makes any event fired on any instance of the passed class also fire a single event through
		/// the class allowing for central handling of events on many instances at once.  Usage:  
		/// Ext.util.Observable.observeClass(Ext.data.Connection);
		/// Ext.data.Connection.on(&apos;beforerequest&apos;, function(con, options) {
		/// console.log(&apos;Ajax request made to &apos; + options.url);
		/// });
		/// </summary>
		/// <htmlSummary>
		/// Sets observability on the passed class constructor.&lt;p&gt;
		/// &lt;p&gt;This makes any event fired on any instance of the passed class also fire a single event through
		/// the &lt;i&gt;class&lt;/i&gt; allowing for central handling of events on many instances at once.&lt;/p&gt;
		/// &lt;p&gt;Usage:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// Ext.util.Observable.observeClass(Ext.data.Connection);
		/// Ext.data.Connection.on(&apos;beforerequest&apos;, function(con, options) {
		/// console.log(&apos;Ajax request made to &apos; + options.url);
		/// });&lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Observable-more.js</definedin>
		/// <param name="c">The class constructor to make observable.</param>
		/// <param name="listeners">An object containing a series of listeners to add. See {@link #addListener}.</param>
		[ScriptName("observeClass")]
		public static void ObserveClass(System.Delegate c, object listeners)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Fires the specified event with the passed parameters (minus the event name).  An event may be set to bubble up an Observable parent hierarchy (See {@link Ext.Component#getBubbleTarget})
		/// by calling {@link #enableBubble}.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Fires the specified event with the passed parameters (minus the event name).&lt;/p&gt;
		/// &lt;p&gt;An event may be set to bubble up an Observable parent hierarchy (See {@link Ext.Component#getBubbleTarget})
		/// by calling {@link #enableBubble}.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The name of the event to fire.</param>
		/// <param name="args">Variable length parameter array - Variable number of parameters are passed to handlers.</param>
		/// <returns>returns false if any of the handlers return false otherwise it returns true.</returns>
		[ScriptName("fireEvent")]
		public bool FireEvent(string eventName, params object[] args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Fires the specified event with the passed parameters (minus the event name).  An event may be set to bubble up an Observable parent hierarchy (See {@link Ext.Component#getBubbleTarget})
		/// by calling {@link #enableBubble}.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Fires the specified event with the passed parameters (minus the event name).&lt;/p&gt;
		/// &lt;p&gt;An event may be set to bubble up an Observable parent hierarchy (See {@link Ext.Component#getBubbleTarget})
		/// by calling {@link #enableBubble}.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The name of the event to fire.</param>
		/// <returns>returns false if any of the handlers return false otherwise it returns true.</returns>
		[ScriptName("fireEvent")]
		public bool FireEvent(string eventName)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to this object.</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">The method the event invokes.</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the handler function is executed.
		/// &lt;b&gt;If omitted, defaults to the object which fired the event.&lt;/b&gt;
		/// </param>
		/// <param name="options">
		/// An object containing handler configuration.
		/// properties. This may contain any of the following properties:&lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;scope&lt;/b&gt; : Object&lt;div class=&quot;sub-desc&quot;&gt;The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the handler function is executed.
		/// &lt;b&gt;If omitted, defaults to the object which fired the event.&lt;/b&gt;&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;delay&lt;/b&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The number of milliseconds to delay the invocation of the handler after the event fires.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;single&lt;/b&gt; : Boolean&lt;div class=&quot;sub-desc&quot;&gt;True to add a handler to handle just the next firing of the event, and then remove itself.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;buffer&lt;/b&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;Causes the handler to be scheduled to run in an {@link Ext.util.DelayedTask} delayed
		/// by the specified number of milliseconds. If the event fires again within that time, the original
		/// handler is &lt;em&gt;not&lt;/em&gt; invoked, but the new handler is scheduled in its place.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;target&lt;/b&gt; : Observable&lt;div class=&quot;sub-desc&quot;&gt;Only call the handler if the event was fired on the target Observable, &lt;i&gt;not&lt;/i&gt;
		/// if the event was bubbled up from a child Observable.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;br&gt;
		/// &lt;p&gt;
		/// &lt;b&gt;Combining Options&lt;/b&gt;&lt;br&gt;
		/// Using the options argument, it is possible to combine different types of listeners:&lt;br&gt;
		/// &lt;br&gt;
		/// A delayed, one-time listener.
		/// <c>
		/// myDataView.on(&apos;click&apos;, this.onClick, this, {
		/// single: true,
		/// delay: 100
		/// });</c>&lt;/pre&gt;
		/// &lt;p&gt;
		/// &lt;b&gt;Attaching multiple handlers in 1 call&lt;/b&gt;&lt;br&gt;
		/// The method also allows for a single argument to be passed which is a config object containing properties
		/// which specify multiple handlers.
		/// &lt;p&gt;
		/// <c>
		/// myGridPanel.on({
		/// &apos;click&apos; : {
		/// fn: this.onClick,
		/// scope: this,
		/// delay: 100
		/// },
		/// &apos;mouseover&apos; : {
		/// fn: this.onMouseOver,
		/// scope: this
		/// },
		/// &apos;mouseout&apos; : {
		/// fn: this.onMouseOut,
		/// scope: this
		/// }
		/// });</c>&lt;/pre&gt;
		/// &lt;p&gt;
		/// Or a shorthand syntax:&lt;br&gt;
		/// <c>
		/// myGridPanel.on({
		/// &apos;click&apos; : this.onClick,
		/// &apos;mouseover&apos; : this.onMouseOver,
		/// &apos;mouseout&apos; : this.onMouseOut,
		/// scope: this
		/// });</c>&lt;/pre&gt;
		/// </param>
		[ScriptName("addListener")]
		public void AddListener(string eventName, System.Delegate handler, object scope, object options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to this object.</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">The method the event invokes.</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the handler function is executed.
		/// &lt;b&gt;If omitted, defaults to the object which fired the event.&lt;/b&gt;
		/// </param>
		[ScriptName("addListener")]
		public void AddListener(string eventName, System.Delegate handler, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to this object.</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">The method the event invokes.</param>
		[ScriptName("addListener")]
		public void AddListener(string eventName, System.Delegate handler)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes an event handler.</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The type of event the handler was associated with.</param>
		/// <param name="handler">The handler to remove. &lt;b&gt;This must be a reference to the function passed into the {@link #addListener} call.&lt;/b&gt;</param>
		/// <param name="scope">The scope originally specified for the handler.</param>
		[ScriptName("removeListener")]
		public void RemoveListener(string eventName, System.Delegate handler, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes an event handler.</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The type of event the handler was associated with.</param>
		/// <param name="handler">The handler to remove. &lt;b&gt;This must be a reference to the function passed into the {@link #addListener} call.&lt;/b&gt;</param>
		[ScriptName("removeListener")]
		public void RemoveListener(string eventName, System.Delegate handler)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Adds the specified events to the list of events which this Observable may fire.</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="o">
		/// Either an object with event names as properties with a value of <c>true</c>
		/// or the first event name string if multiple event names are being passed as separate parameters.
		/// </param>
		/// <param name="Optional">
		/// Event name if multiple event names are being passed as separate parameters.
		/// Usage:<c>
		/// this.addEvents(&apos;storeloaded&apos;, &apos;storecleared&apos;);
		/// </c>&lt;/pre&gt;
		/// </param>
		[ScriptName("addEvents")]
		public void AddEvents(object o, string Optional)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Adds the specified events to the list of events which this Observable may fire.</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="o">
		/// Either an object with event names as properties with a value of <c>true</c>
		/// or the first event name string if multiple event names are being passed as separate parameters.
		/// </param>
		/// <param name="Optional">
		/// Event name if multiple event names are being passed as separate parameters.
		/// Usage:<c>
		/// this.addEvents(&apos;storeloaded&apos;, &apos;storecleared&apos;);
		/// </c>&lt;/pre&gt;
		/// </param>
		[ScriptName("addEvents")]
		public void AddEvents(string o, string Optional)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to this object (shorthand for {@link #addListener}.)</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The type of event to listen for</param>
		/// <param name="handler">The method the event invokes</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the handler function is executed.
		/// &lt;b&gt;If omitted, defaults to the object which fired the event.&lt;/b&gt;
		/// </param>
		/// <param name="options">An object containing handler configuration.</param>
		[ScriptName("on")]
		public static void On(string eventName, System.Delegate handler, object scope, object options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to this object (shorthand for {@link #addListener}.)</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The type of event to listen for</param>
		/// <param name="handler">The method the event invokes</param>
		/// <param name="scope">
		/// The scope (<c>&lt;b&gt;this&lt;/b&gt;</c> reference) in which the handler function is executed.
		/// &lt;b&gt;If omitted, defaults to the object which fired the event.&lt;/b&gt;
		/// </param>
		[ScriptName("on")]
		public static void On(string eventName, System.Delegate handler, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to this object (shorthand for {@link #addListener}.)</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The type of event to listen for</param>
		/// <param name="handler">The method the event invokes</param>
		[ScriptName("on")]
		public static void On(string eventName, System.Delegate handler)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes an event handler (shorthand for {@link #removeListener}.)</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The type of event the handler was associated with.</param>
		/// <param name="handler">The handler to remove. &lt;b&gt;This must be a reference to the function passed into the {@link #addListener} call.&lt;/b&gt;</param>
		/// <param name="scope">The scope originally specified for the handler.</param>
		[ScriptName("un")]
		public static void Un(string eventName, System.Delegate handler, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes an event handler (shorthand for {@link #removeListener}.)</summary>
		/// <definedin>src\ext-core\src\util\Observable.js</definedin>
		/// <param name="eventName">The type of event the handler was associated with.</param>
		/// <param name="handler">The handler to remove. &lt;b&gt;This must be a reference to the function passed into the {@link #addListener} call.&lt;/b&gt;</param>
		[ScriptName("un")]
		public static void Un(string eventName, System.Delegate handler)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Enables events fired by this Observable to bubble up an owner hierarchy by calling
		/// this.getBubbleTarget() if present. There is no implementation in the Observable base class.  This is commonly used by Ext.Components to bubble events to owner Containers. See {@link Ext.Component.getBubbleTarget}. The default
		/// implementation in Ext.Component returns the Component&apos;s immediate owner. But if a known target is required, this can be overridden to
		/// access the required target more quickly.  Example:  
		/// Ext.override(Ext.form.Field, {
		/// // Add functionality to Field&apos;s initComponent to enable the change event to bubble
		/// initComponent : Ext.form.Field.prototype.initComponent.createSequence(function() {
		/// this.enableBubble(&apos;change&apos;);
		/// }),
		///
		/// // We know that we want Field&apos;s events to bubble directly to the FormPanel.
		/// getBubbleTarget : function() {
		/// if (!this.formPanel) {
		/// this.formPanel = this.findParentByType(&apos;form&apos;);
		/// }
		/// return this.formPanel;
		/// }
		/// });
		///
		/// var myForm = new Ext.formPanel({
		/// ..
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Enables events fired by this Observable to bubble up an owner hierarchy by calling
		/// &lt;code&gt;this.getBubbleTarget()&lt;/code&gt; if present. There is no implementation in the Observable base class.&lt;/p&gt;
		/// &lt;p&gt;This is commonly used by Ext.Components to bubble events to owner Containers. See {@link Ext.Component.getBubbleTarget}. The default
		/// implementation in Ext.Component returns the Component&apos;s immediate owner. But if a known target is required, this can be overridden to
		/// access the required target more quickly.&lt;/p&gt;
		/// &lt;p&gt;Example:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// Ext.override(Ext.form.Field, {
		/// // Add functionality to Field&amp;#39;s initComponent to enable the change event to bubble
		/// initComponent : Ext.form.Field.prototype.initComponent.createSequence(function() {
		/// this.enableBubble(&apos;change&apos;);
		/// }),
		///
		/// // We know that we want Field&amp;#39;s events to bubble directly to the FormPanel.
		/// getBubbleTarget : function() {
		/// if (!this.formPanel) {
		/// this.formPanel = this.findParentByType(&apos;form&apos;);
		/// }
		/// return this.formPanel;
		/// }
		/// });
		///
		/// var myForm = new Ext.formPanel({
		/// title: &apos;User Details&apos;,
		/// items: [{
		/// ...
		/// }],
		/// listeners: {
		/// change: function() {
		/// // Title goes red if form has been modified.
		/// myForm.header.setStyle(&apos;color&apos;, &apos;red&apos;);
		/// }
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Observable-more.js</definedin>
		/// <param name="events">The event name to bubble, or an Array of event names.</param>
		[ScriptName("enableBubble")]
		public void EnableBubble(string events)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Enables events fired by this Observable to bubble up an owner hierarchy by calling
		/// this.getBubbleTarget() if present. There is no implementation in the Observable base class.  This is commonly used by Ext.Components to bubble events to owner Containers. See {@link Ext.Component.getBubbleTarget}. The default
		/// implementation in Ext.Component returns the Component&apos;s immediate owner. But if a known target is required, this can be overridden to
		/// access the required target more quickly.  Example:  
		/// Ext.override(Ext.form.Field, {
		/// // Add functionality to Field&apos;s initComponent to enable the change event to bubble
		/// initComponent : Ext.form.Field.prototype.initComponent.createSequence(function() {
		/// this.enableBubble(&apos;change&apos;);
		/// }),
		///
		/// // We know that we want Field&apos;s events to bubble directly to the FormPanel.
		/// getBubbleTarget : function() {
		/// if (!this.formPanel) {
		/// this.formPanel = this.findParentByType(&apos;form&apos;);
		/// }
		/// return this.formPanel;
		/// }
		/// });
		///
		/// var myForm = new Ext.formPanel({
		/// ..
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Enables events fired by this Observable to bubble up an owner hierarchy by calling
		/// &lt;code&gt;this.getBubbleTarget()&lt;/code&gt; if present. There is no implementation in the Observable base class.&lt;/p&gt;
		/// &lt;p&gt;This is commonly used by Ext.Components to bubble events to owner Containers. See {@link Ext.Component.getBubbleTarget}. The default
		/// implementation in Ext.Component returns the Component&apos;s immediate owner. But if a known target is required, this can be overridden to
		/// access the required target more quickly.&lt;/p&gt;
		/// &lt;p&gt;Example:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// Ext.override(Ext.form.Field, {
		/// // Add functionality to Field&amp;#39;s initComponent to enable the change event to bubble
		/// initComponent : Ext.form.Field.prototype.initComponent.createSequence(function() {
		/// this.enableBubble(&apos;change&apos;);
		/// }),
		///
		/// // We know that we want Field&amp;#39;s events to bubble directly to the FormPanel.
		/// getBubbleTarget : function() {
		/// if (!this.formPanel) {
		/// this.formPanel = this.findParentByType(&apos;form&apos;);
		/// }
		/// return this.formPanel;
		/// }
		/// });
		///
		/// var myForm = new Ext.formPanel({
		/// title: &apos;User Details&apos;,
		/// items: [{
		/// ...
		/// }],
		/// listeners: {
		/// change: function() {
		/// // Title goes red if form has been modified.
		/// myForm.header.setStyle(&apos;color&apos;, &apos;red&apos;);
		/// }
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\util\Observable-more.js</definedin>
		/// <param name="events">The event name to bubble, or an Array of event names.</param>
		[ScriptName("enableBubble")]
		public void EnableBubble(System.Array events)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Starts capture on the specified Observable. All events will be passed
		/// to the supplied function with the event name + standard signature of the event
		/// before the event is fired. If the supplied function returns false,
		/// the event will not fire.
		/// </summary>
		/// <htmlSummary>
		/// Starts capture on the specified Observable. All events will be passed
		/// to the supplied function with the event name + standard signature of the event
		/// &lt;b&gt;before&lt;/b&gt; the event is fired. If the supplied function returns false,
		/// the event will not fire.
		/// </htmlSummary>
		/// <definedin>src\util\Observable-more.js</definedin>
		/// <param name="o">The Observable to capture events from.</param>
		/// <param name="fn">The function to call when an event is fired.</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the function is executed. Defaults to the Observable firing the event.</param>
		[ScriptName("capture")]
		public static void Capture(ext.util.Observable o, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Starts capture on the specified Observable. All events will be passed
		/// to the supplied function with the event name + standard signature of the event
		/// before the event is fired. If the supplied function returns false,
		/// the event will not fire.
		/// </summary>
		/// <htmlSummary>
		/// Starts capture on the specified Observable. All events will be passed
		/// to the supplied function with the event name + standard signature of the event
		/// &lt;b&gt;before&lt;/b&gt; the event is fired. If the supplied function returns false,
		/// the event will not fire.
		/// </htmlSummary>
		/// <definedin>src\util\Observable-more.js</definedin>
		/// <param name="o">The Observable to capture events from.</param>
		/// <param name="fn">The function to call when an event is fired.</param>
		[ScriptName("capture")]
		public static void Capture(ext.util.Observable o, System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
	}
}
